Switch to new method of shutting down domains.
40c9c469hJ_IlatRne-9QEa0-wlquw tools/xenmgr/lib/server/console.py
40c9c469UcNJh_NuLU0ytorM0Lk5Ow tools/xenmgr/lib/server/controller.py
40c9c469vHh-qLiiubdbKEQbJf18Zw tools/xenmgr/lib/server/cstruct.py
+40d83983OXjt-y3HjSCcuoPp9rzvmw tools/xenmgr/lib/server/domain.py
40c9c469yrm31i60pGKslTi2Zgpotg tools/xenmgr/lib/server/messages.py
40c9c46925x-Rjb0Cv2f1-l2jZrPYg tools/xenmgr/lib/server/netif.py
40c9c469ZqILEQ8x6yWy0_51jopiCg tools/xenmgr/lib/server/params.py
"""Pause domain execution.
"""
dom = int(id)
+ eserver.inject('xend.domain.pause', id)
return xc.domain_pause(dom=dom)
- def domain_shutdown(self, id):
+ def domain_shutdown(self, id, reason='poweroff'):
"""Shutdown domain (nicely).
"""
dom = int(id)
if dom <= 0:
return 0
- eserver.inject('xend.domain.shutdown', id)
- val = xc.domain_destroy(dom=dom) # FIXME -- send CMSG_SHUTDOWN
+ eserver.inject('xend.domain.shutdown', [id, reason])
+ val = xend.domain_shutdown(dom, reason)
self.refresh()
return val
def domain_halt(self, id):
- """Shutdown domain immediately.
+ """Terminate domain immediately.
"""
dom = int(id)
if dom <= 0:
susp = (self.info['shutdown'] and 's') or '-'
crash = (self.info['crashed'] and 'c') or '-'
state = run + block + stop + susp + crash
- sxpr.append(['cpu', self.info['cpu']])
sxpr.append(['state', state])
+ if self.info['shutdown']:
+ reasons = ["poweroff", "reboot", "suspend"]
+ reason = reasons[info['shutdown_reason']]
+ sxpr.append(['shutdown_reason', reason])
+ sxpr.append(['cpu', self.info['cpu']])
sxpr.append(['cpu_time', self.info['cpu_time']/1e9])
if self.console:
sxpr.append(self.console.sxpr())
import blkif
import netif
import console
+import domain
from params import *
DEBUG = 1
proto.factory = self
return proto
+class VirqClient:
+ def __init__(self, daemon):
+ self.daemon = daemon
+
+ def virqReceived(self, virq):
+ print 'VirqClient.virqReceived>', virq
+
+ def lostChannel(self, channel):
+ print 'VirqClient.lostChannel>', channel
+
class Daemon:
"""The xend daemon.
"""
self.listenMgmt()
self.listenEvent()
self.listenNotifier()
+ self.listenVirq()
SrvServer.create()
reactor.run()
def createFactories(self):
self.channelF = channel.channelFactory()
+ self.domainCF = domain.DomainControllerFactory()
self.blkifCF = blkif.BlkifControllerFactory()
self.netifCF = netif.NetifControllerFactory()
self.consoleCF = console.ConsoleControllerFactory()
p.startListening()
return p
+ def listenVirq(self):
+ virqChan = self.channelF.virqChannel(channel.VIRQ_DOM_EXC)
+ virqChan.registerClient(VirqClient(self))
+
def exit(self):
reactor.diconnectAll()
sys.exit(0)
if console.conn:
console.conn.loseConnection()
- def domain_start(self, id):
- """Start domain running.
+ def domain_shutdown(self, dom, reason):
+ """Shutdown a domain.
"""
- dom = int(id)
- if dom <= 0: return 0
- return xc.domain_start(dom=dom)
+ ctrl = self.domainCF.getInstanceByDom(dom)
+ if not ctrl:
+ raise ValueError('No domain controller: %d' % dom)
+ ctrl.shutdown(reason)
+ return 0
- def domain_stop(self, id):
- """Stop domain running.
- """
- dom = int(id)
- if dom <= 0: return 0
- xc.domain_stop(dom=dom)
-
- def domain_destroy(self, id, force=0):
- """Destroy a domain. Shutdown if force=0, terminate immediately if force=1.
- """
- dom = int(id)
- if dom <= 0: return 0
- return xc.domain_destroy(dom=dom, force=force)
-
-
def instance():
global inst
try:
def form(self, req):
req.write('<form method="post" action="%s">' % req.prePathURL())
- req.write('<input type="submit" name="op" value="start">')
- req.write('<input type="submit" name="op" value="stop">')
+ req.write('<input type="submit" name="op" value="unpause">')
+ req.write('<input type="submit" name="op" value="pause">')
req.write('<input type="submit" name="op" value="shutdown">')
req.write('<input type="submit" name="op" value="halt">')
req.write('<br><input type="submit" name="op" value="migrate">')
import xend.utils
from messages import msgTypeName
+VIRQ_MISDIRECT = 0 # Catch-all interrupt for unbound VIRQs.
+VIRQ_TIMER = 1 # Timebase update, and/or requested timeout.
+VIRQ_DEBUG = 2 # Request guest to dump debug info.
+VIRQ_CONSOLE = 3 # (DOM0) bytes received on emergency console.
+VIRQ_DOM_EXC = 4 # (DOM0) Exceptional event for some domain.
+
def eventChannel(dom1, dom2):
return xc.evtchn_bind_interdomain(dom1=dom1, dom2=dom2)
self.virq = virq
# Notification port (int).
self.port = xc.evtchn_bind_virq(virq)
- self.idx = port
+ self.idx = self.port
# Clients to call when a virq arrives.
self.clients = []
pass
def registerChannel(self):
+ print 'CtrlMsgRcvr>registerChannel>', self
self.channel = self.channelFactory.domChannel(self.dom)
self.idx = self.channel.getIndex()
if self.majorTypes:
self.channel.registerDevice(self.majorTypes, self)
def deregisterChannel(self):
+ print 'CtrlMsgRcvr>deregisterChannel>', self
if self.channel:
self.channel.deregisterDevice(self)
del self.channel
self.instances = {}
self.dlist = []
self.dom = 0
+ # Timeout (in seconds) for deferreds.
+ self.timeout = 10
def addInstance(self, instance):
self.instances[instance.idx] = instance
def addDeferred(self):
d = defer.Deferred()
+ if self.timeout > 0:
+ # The deferred will error if not called before timeout.
+ d.setTimeout(self.timeout)
self.dlist.append(d)
return d
--- /dev/null
+import channel
+import controller
+from messages import *
+
+class DomainControllerFactory(controller.ControllerFactory):
+ """Factory for creating domain controllers.
+ """
+
+ def createInstance(self, dom):
+ d = DomainController(self, dom)
+ self.addInstance(d)
+ return d
+
+ def getInstanceByDom(self, dom):
+ for inst in self.instances.values():
+ if inst.dom == dom:
+ return inst
+ inst = self.createInstance(dom)
+ return inst
+
+
+class DomainController(controller.Controller):
+ """Generic controller for a domain.
+ """
+
+ reasons = {'poweroff' : 'shutdown_poweroff_t',
+ 'reboot' : 'shutdown_reboot_t',
+ 'suspend' : 'shutdown_suspend_t' }
+
+ def __init__(self, factory, dom):
+ controller.Controller.__init__(self, factory, dom)
+ self.majorTypes = [ CMSG_SHUTDOWN ]
+ self.registerChannel()
+ print 'DomainController>', self, self.channel, self.idx
+
+ def shutdown(self, reason):
+ msgtype = self.reasons.get(reason)
+ if not msgtype:
+ raise ValueError('invalid reason:' + reason)
+ msg = packMsg(msgtype, {})
+ self.writeRequest(msg)
CMSG_CONSOLE = 0
-console_formats = { 'console_data': (CMSG_CONSOLE, 0, "?") }
+console_formats = { 'console_data': (CMSG_CONSOLE, 0) }
msg_formats.update(console_formats)
blkif_formats = {
'blkif_be_connect_t':
- (CMSG_BLKIF_BE, CMSG_BLKIF_BE_CONNECT, "QIILI"),
+ (CMSG_BLKIF_BE, CMSG_BLKIF_BE_CONNECT),
'blkif_be_create_t':
- (CMSG_BLKIF_BE, CMSG_BLKIF_BE_CREATE, "QII"),
+ (CMSG_BLKIF_BE, CMSG_BLKIF_BE_CREATE),
'blkif_be_destroy_t':
- (CMSG_BLKIF_BE, CMSG_BLKIF_BE_DESTROY, "QII"),
+ (CMSG_BLKIF_BE, CMSG_BLKIF_BE_DESTROY),
'blkif_be_vbd_create_t':
- (CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_CREATE, "QIHII"),
+ (CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_CREATE),
'blkif_be_vbd_grow_t':
- (CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_GROW , "QIHHHQQI"),
+ (CMSG_BLKIF_BE, CMSG_BLKIF_BE_VBD_GROW),
'blkif_fe_interface_status_changed_t':
- (CMSG_BLKIF_FE, CMSG_BLKIF_FE_INTERFACE_STATUS_CHANGED, "III"),
+ (CMSG_BLKIF_FE, CMSG_BLKIF_FE_INTERFACE_STATUS_CHANGED),
'blkif_fe_driver_status_changed_t':
- (CMSG_BLKIF_FE, CMSG_BLKIF_FE_DRIVER_STATUS_CHANGED, "?"),
+ (CMSG_BLKIF_FE, CMSG_BLKIF_FE_DRIVER_STATUS_CHANGED),
'blkif_fe_interface_connect_t':
- (CMSG_BLKIF_FE, CMSG_BLKIF_FE_INTERFACE_CONNECT, "IL"),
+ (CMSG_BLKIF_FE, CMSG_BLKIF_FE_INTERFACE_CONNECT),
}
msg_formats.update(blkif_formats)
netif_formats = {
'netif_be_connect_t':
- (CMSG_NETIF_BE, CMSG_NETIF_BE_CONNECT, "QIILLI"),
+ (CMSG_NETIF_BE, CMSG_NETIF_BE_CONNECT),
'netif_be_create_t':
- (CMSG_NETIF_BE, CMSG_NETIF_BE_CREATE, "QIBBBBBBBBI"),
+ (CMSG_NETIF_BE, CMSG_NETIF_BE_CREATE),
'netif_be_destroy_t':
- (CMSG_NETIF_BE, CMSG_NETIF_BE_DESTROY, "QII"),
+ (CMSG_NETIF_BE, CMSG_NETIF_BE_DESTROY),
'netif_be_disconnect_t':
- (CMSG_NETIF_BE, CMSG_NETIF_BE_DISCONNECT, "QII"),
+ (CMSG_NETIF_BE, CMSG_NETIF_BE_DISCONNECT),
'netif_be_driver_status_changed_t':
- (CMSG_NETIF_BE, CMSG_NETIF_BE_DRIVER_STATUS_CHANGED, "QII"),
+ (CMSG_NETIF_BE, CMSG_NETIF_BE_DRIVER_STATUS_CHANGED),
'netif_fe_driver_status_changed_t':
- (CMSG_NETIF_FE, CMSG_NETIF_FE_DRIVER_STATUS_CHANGED, "II"),
+ (CMSG_NETIF_FE, CMSG_NETIF_FE_DRIVER_STATUS_CHANGED),
'netif_fe_interface_connect_t':
- (CMSG_NETIF_FE, CMSG_NETIF_FE_INTERFACE_CONNECT, "ILL"),
+ (CMSG_NETIF_FE, CMSG_NETIF_FE_INTERFACE_CONNECT),
'netif_fe_interface_status_changed_t':
- (CMSG_NETIF_FE, CMSG_NETIF_FE_INTERFACE_STATUS_CHANGED, "IIIBBBBBBBB"),
+ (CMSG_NETIF_FE, CMSG_NETIF_FE_INTERFACE_STATUS_CHANGED),
}
msg_formats.update(netif_formats)
#============================================================================
-CMSG_SUSPEND = 5
CMSG_SHUTDOWN = 6
-CMSG_SHUTDOWN_HALT = 0
-CMSG_SHUTDOWN_POWEROFF = 1
-CMSG_SHUTDOWN_REBOOT = 2
+CMSG_SHUTDOWN_POWEROFF = 0
+CMSG_SHUTDOWN_REBOOT = 1
+CMSG_SHUTDOWN_SUSPEND = 2
STOPCODE_shutdown = 0
STOPCODE_reboot = 1
STOPCODE_suspend = 2
-ctrlif_formats = {
- 'ctrlif_suspend_t':
- (CMSG_SUSPEND, 0, "??"),
-
- 'ctrlif_shutdown_halt_t':
- (CMSG_SHUTDOWN, CMSG_SHUTDOWN_HALT, "??"),
-
- 'ctrlif_shutdown_poweroff_t':
- (CMSG_SHUTDOWN, CMSG_SHUTDOWN_POWEROFF, "??"),
+shutdown_formats = {
+ 'shutdown_poweroff_t':
+ (CMSG_SHUTDOWN, CMSG_SHUTDOWN_POWEROFF),
- 'ctrlif_shutdown_reboot_t':
- (CMSG_SHUTDOWN, CMSG_SHUTDOWN_REBOOT, "??"),
+ 'shutdown_reboot_t':
+ (CMSG_SHUTDOWN, CMSG_SHUTDOWN_REBOOT),
+
+ 'shutdown_suspend_t':
+ (CMSG_SHUTDOWN, CMSG_SHUTDOWN_SUSPEND),
}
-msg_formats.update(ctrlif_formats)
+msg_formats.update(shutdown_formats)
#============================================================================
def packMsg(ty, params):
if DEBUG: print '>packMsg', ty, params
- (major, minor, packing) = msg_formats[ty]
+ (major, minor) = msg_formats[ty]
args = {}
for (k, v) in params.items():
if k == 'mac':
setip = (opts.hostname or opts.netmask
or opts.gateway or opts.dhcp or opts.interface)
if not setip: return
- if not opts
+ #if not opts
ip = (opts.ip
+ ':'
+ ':' + opts.gateway
Shutdown one or more domains gracefully.""")
gopts.opt('help', short='h',
- fn=set_value, default=0,
+ fn=set_true, default=0,
use="Print this help.")
gopts.opt('all', short='a',
shutdown(opts, None, opts.wait)
def main_dom(opts, args):
- if len(args) < 2: opts.err('Missing domain')
- dom = argv[1]
+ if len(args) < 1: opts.err('Missing domain')
+ dom = args[0]
try:
domid = int(dom)
except:
args = opts.parse(argv)
if opts.help:
opts.usage()
+ return
+ print 'shutdown.main>', len(args), args
if opts.all:
main_all(opts, args)
else:
projects / xen.git / commitdiff